JavaScript SharedArrayBuffer Låsfri Datastrukturer: Atomare Operationer

Inden for moderne webudvikling og server-side JavaScript-miljøer som Node.js vokser behovet for effektiv parallelprogrammering konstant. Efterhånden som applikationer bliver mere komplekse og kræver højere ydeevne, udforsker udviklere i stigende grad teknikker til at udnytte flere kerner og tråde. Et stærkt værktøj til at opnå dette i JavaScript er SharedArrayBuffer, kombineret med Atomics-operationer, som muliggør oprettelsen af låsfri datastrukturer.

Introduktion til Parallelprogrammering i JavaScript

Traditionelt har JavaScript været kendt som et enkelttrådet sprog. Det betyder, at kun én opgave kan udføres ad gangen inden for en given eksekveringskontekst. Selvom dette forenkler mange aspekter af udviklingen, kan det også være en flaskehals for beregningsintensive opgaver. Web Workers giver en måde at eksekvere JavaScript-kode i baggrundstråde, men kommunikation mellem workers har traditionelt været asynkron og involveret kopiering af data.

SharedArrayBuffer ændrer dette ved at tilbyde et hukommelsesområde, som flere tråde kan tilgå samtidigt. Denne delte adgang introducerer dog potentialet for race conditions og datakorruption. Det er her, Atomics kommer ind i billedet. Atomics leverer et sæt atomare operationer, der garanterer, at operationer på delt hukommelse udføres udeleligt, hvilket forhindrer datakorruption.

Forståelse af SharedArrayBuffer

SharedArrayBuffer er et JavaScript-objekt, der repræsenterer en rå binær databuffer af fast længde. I modsætning til en almindelig ArrayBuffer kan en SharedArrayBuffer deles mellem flere tråde (Web Workers) uden at kræve eksplicit kopiering af dataene. Dette muliggør ægte parallelprogrammering med delt hukommelse.

Eksempel: Oprettelse af en SharedArrayBuffer

            
const sab = new SharedArrayBuffer(1024); // 1KB SharedArrayBuffer

            

              
                Copy
              
            
          

For at tilgå dataene i SharedArrayBuffer skal du oprette en typed array-visning, såsom Int32Array eller Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Dette opretter en Int32Array-visning over SharedArrayBuffer, hvilket giver dig mulighed for at læse og skrive 32-bit heltal til den delte hukommelse.

Rollen for Atomics

Atomics er et globalt objekt, der leverer atomare operationer. Disse operationer garanterer, at læsninger og skrivninger til delt hukommelse udføres atomart, hvilket forhindrer race conditions. De er afgørende for at bygge låsfri datastrukturer, der sikkert kan tilgås af flere tråde.

Vigtige Atomare Operationer:

• Atomics.load(typedArray, index): Læser en værdi fra det angivne indeks i det typede array.
• Atomics.store(typedArray, index, value): Skriver en værdi til det angivne indeks i det typede array.
• Atomics.add(typedArray, index, value): Tilføjer en værdi til værdien på det angivne indeks.
• Atomics.sub(typedArray, index, value): Trækker en værdi fra værdien på det angivne indeks.
• Atomics.exchange(typedArray, index, value): Erstatter værdien på det angivne indeks med en ny værdi og returnerer den oprindelige værdi.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Sammenligner værdien på det angivne indeks med en forventet værdi. Hvis de er ens, erstattes værdien med en ny værdi. Returnerer den oprindelige værdi.
• Atomics.wait(typedArray, index, expectedValue, timeout): Venter på, at en værdi på det angivne indeks ændrer sig fra en forventet værdi.
• Atomics.wake(typedArray, index, count): Vækker et angivet antal ventende, der venter på en værdi på det angivne indeks.

Disse operationer er fundamentale for at bygge låsfri algoritmer.

Opbygning af Låsfri Datastrukturer

Låsfri datastrukturer er datastrukturer, der kan tilgås af flere tråde samtidigt uden brug af låse. Dette eliminerer overhead og potentielle deadlocks forbundet med traditionelle låsemekanismer. Ved hjælp af SharedArrayBuffer og Atomics kan vi implementere forskellige låsfri datastrukturer i JavaScript.

1. Låsfri Tæller

Et simpelt eksempel er en låsfri tæller. Denne tæller kan øges og mindskes af flere tråde uden nogen låse.

            
class LockFreeCounter {
  constructor() {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.view = new Int32Array(this.buffer);
  }

  increment() {
    Atomics.add(this.view, 0, 1);
  }

  decrement() {
    Atomics.sub(this.view, 0, 1);
  }

  getValue() {
    return Atomics.load(this.view, 0);
  }
}

// Eksempel på brug i to web workers
const counter = new LockFreeCounter();

// Worker 1
for (let i = 0; i < 1000; i++) {
  counter.increment();
}

// Worker 2
for (let i = 0; i < 1000; i++) {
  counter.decrement();
}

// Efter begge workers er færdige (ved hjælp af en mekanisme som Promise.all for at sikre fuldførelse)
// counter.getValue() bør være tæt på 0. Det faktiske resultat kan variere på grund af samtidighed

            

              
                Copy
              
            
          

2. Låsfri Stak

Et mere komplekst eksempel er en låsfri stak. Denne stak bruger en linked list-struktur gemt i SharedArrayBuffer og atomare operationer til at administrere head-pointeren.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Hver node kræver plads til en værdi og en pointer til næste node
    // Alloker plads til noder og en head-pointer
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Værdi & Næste-pointer for hver node + Head-pointer
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // indeks hvor head-pointeren er gemt
    Atomics.store(this.view, this.headIndex, -1); // Initialiser head til null (-1)

    // Initialiser noderne med deres 'next'-pointere til senere genbrug.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // sidste node peger på null
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Initialiser hovedet af den frie liste til den første node
  }

  setNext(nodeIndex, nextIndex) {
     this.view[nodeIndex * 2 + 1] = nextIndex;
  }

  getNext(nodeIndex) {
     return this.view[nodeIndex * 2 + 1];
  }

  getValue(nodeIndex) {
    return this.view[nodeIndex * 2];
  }

  setValue(nodeIndex, value){ 
      this.view[nodeIndex*2] = value;
  }

  push(value) {
    let nodeIndex = this.freeListHead; // forsøg at hente fra fri liste
    if (nodeIndex === -1) {
      return false; // stak-overflow
    }

    let nextFree = this.getNext(nodeIndex);
    // forsøg atomart at opdatere hovedet af den frie liste til nextFree. Hvis vi fejler, har en anden allerede taget den.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // prøv igen ved konkurrence
    }

    // vi har en node, skriv værdien ind i den
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Sammenlign-og-byt head med newHead. Hvis det mislykkes, betyder det, at en anden tråd har pushet i mellemtiden
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // succes
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // stakken er tom
    }

    let next = this.getNext(head);
    // Forsøg at opdatere head til next. Hvis det mislykkes, betyder det, at en anden tråd har poppet i mellemtiden
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // prøv igen, eller indiker fejl.
    }

    const value = this.getValue(head);

    // Returner noden til den frie liste.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // peg den frigivne node til den nuværende frie liste
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // succes
  }
}

// Eksempel på brug (i en worker):
const stack = new LockFreeStack(1024); // Opret en stak med 1024 elementer

//pusher
stack.push(10);
stack.push(20);

//popper
const value1 = stack.pop(); // Værdi 20
const value2 = stack.pop(); // Værdi 10


            

              
                Copy
              
            
          

3. Låsfri Kø

At bygge en låsfri kø indebærer at administrere både head- og tail-pointere atomart. Dette er mere komplekst end stakken, men følger lignende principper ved hjælp af Atomics.compareExchange.

Bemærk: En detaljeret implementering af en låsfri kø ville være mere omfattende og ligger uden for rammerne af denne introduktion, men ville involvere lignende koncepter som stakken, omhyggelig håndtering af hukommelse og brug af CAS (Compare-and-Swap) operationer for at garantere sikker samtidig adgang.

Fordele ved Låsfri Datastrukturer

• Forbedret Ydeevne: At fjerne låse reducerer overhead og undgår konkurrence, hvilket fører til højere gennemløb.
• Undgåelse af Deadlocks: Låsfri algoritmer er i sagens natur fri for deadlocks, da de ikke er afhængige af låse.
• Øget Parallelisme: Giver flere tråde mulighed for at tilgå datastrukturen samtidigt uden at blokere hinanden.

Udfordringer og Overvejelser

• Kompleksitet: Implementering af låsfri algoritmer kan være komplekst og fejlbehæftet. Det kræver en dyb forståelse af parallelprogrammering og hukommelsesmodeller.
• ABA-problemet: ABA-problemet opstår, når en værdi ændres fra A til B og derefter tilbage til A. En compare-and-swap-operation kan fejlagtigt lykkes, hvilket fører til datakorruption. Løsninger på ABA-problemet involverer ofte at tilføje en tæller til den værdi, der sammenlignes.
• Hukommelsesstyring: Omhyggelig hukommelsesstyring er påkrævet for at undgå hukommelseslækager og sikre korrekt allokering og deallokering af ressourcer. Teknikker som hazard pointers eller epokebaseret genvinding kan anvendes.
• Debugging: Debugging af parallel kode kan være udfordrende, da problemer kan være svære at reproducere. Værktøjer som debuggere og profilers kan være nyttige.

Praktiske Eksempler og Anvendelsestilfælde

Låsfri datastrukturer kan bruges i forskellige scenarier, hvor høj samtidighed og lav latenstid er påkrævet:

• Spiludvikling: Håndtering af spiltilstand og synkronisering af data mellem flere spiltråde.
• Realtidssystemer: Behandling af realtidsdatastrømme og hændelser.
• Højtydende Servere: Håndtering af samtidige anmodninger og administration af delte ressourcer.
• Databehandling: Parallel behandling af store datasæt.
• Finansielle Applikationer: Udførelse af højfrekvenshandel og risikostyringsberegninger.

Eksempel: Realtidsdatabehandling i en Finansiel Applikation

Forestil dig en finansiel applikation, der behandler realtidsdata fra aktiemarkedet. Flere tråde skal tilgå og opdatere delte datastrukturer, der repræsenterer aktiekurser, ordrebøger og handelspositioner. Ved at bruge låsfri datastrukturer kan applikationen effektivt håndtere den store mængde indkommende data og sikre rettidig udførelse af handler.

Browserkompatibilitet og Sikkerhed

SharedArrayBuffer og Atomics er bredt understøttet i moderne browsere. Men på grund af sikkerhedsproblemer relateret til Spectre- og Meltdown-sårbarhederne, deaktiverede browsere oprindeligt SharedArrayBuffer som standard. For at genaktivere det skal du typisk indstille følgende HTTP-svarheadere:

            
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin

            

              
                Copy
              
            
          

Disse headere isolerer din oprindelse og forhindrer lækage af information på tværs af oprindelser. Sørg for, at din server er korrekt konfigureret til at sende disse headere, når den serverer JavaScript-kode, der bruger SharedArrayBuffer.

Alternativer til SharedArrayBuffer og Atomics

Selvom SharedArrayBuffer og Atomics giver stærke værktøjer til parallelprogrammering, findes der andre tilgange:

• Beskedudveksling: Brug af asynkron beskedudveksling mellem Web Workers. Dette er en mere traditionel tilgang, men indebærer kopiering af data mellem tråde.
• WebAssembly (WASM) Tråde: WebAssembly understøtter også delt hukommelse og atomare operationer, som kan bruges til at bygge højtydende parallelle applikationer.
• Service Workers: Selvom de primært er til caching og baggrundsopgaver, kan service workers også bruges til parallel behandling ved hjælp af beskedudveksling.

Den bedste tilgang afhænger af de specifikke krav i din applikation. SharedArrayBuffer og Atomics er mest velegnede, når du har brug for at dele store mængder data mellem tråde med minimalt overhead og streng synkronisering.

Bedste Praksis

• Hold det Simpelt: Start med simple låsfri algoritmer og øg gradvist kompleksiteten efter behov.
• Grundig Testning: Test din parallelle kode grundigt for at identificere og rette race conditions og andre parallelprogrammeringsproblemer.
• Kode-gennemgang: Få din kode gennemgået af erfarne udviklere, der er bekendt med parallelprogrammering.
• Brug Ydelsesprofilering: Brug værktøjer til ydelsesprofilering til at identificere flaskehalse og optimere din kode.
• Dokumenter Din Kode: Dokumenter din kode tydeligt for at forklare designet og implementeringen af dine låsfri algoritmer.

Konklusion

SharedArrayBuffer og Atomics giver en stærk mekanisme til at bygge låsfri datastrukturer i JavaScript, hvilket muliggør effektiv parallelprogrammering. Selvom kompleksiteten ved at implementere låsfri algoritmer kan være skræmmende, er de potentielle ydelsesfordele betydelige for applikationer, der kræver høj samtidighed og lav latenstid. Efterhånden som JavaScript fortsætter med at udvikle sig, vil disse værktøjer blive stadig vigtigere for at bygge højtydende, skalerbare applikationer. At omfavne disse teknikker, sammen med en stærk forståelse af principperne for parallelprogrammering, giver udviklere mulighed for at skubbe grænserne for JavaScript-ydeevne i en verden med flere kerner.

Yderligere Læringsressourcer

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Artikler om låsfri datastrukturer og algoritmer.
• Blogindlæg og artikler om parallelprogrammering i JavaScript.